package com.atguigu.principle.liskov.improve;

/**
 * @author ccc
 * @create 2020-07-09 16:58
 * 里氏替换原则
 */
public class liskov01 {
    public static void main(String[] args) {
//        A a = new A();
//        System.out.println("11-3=" + a.func1(11,3));
//        System.out.println("1-8=" + a.func1(1,8));

        System.out.println("=========================");

        B b = new B();
        //因为B类不再继承A类，因此调用者，不会认为func1是求减法了
        System.out.println("11+3=" + b.func1(11, 3));//这里本意是求出11+3的结果
        System.out.println("1+8=" + b.func1(1, 8));
        System.out.println("11+3+9=" + b.func2(11, 3));

        //使用组合仍然可以使用到A类相关方法
        System.out.println("11-3=" + b.func3(11,3));//这里本意是求出11- 3的结果

    }
}
//创建一个更加基础的基类

class Base {
    //把更加基础的方法和成员写到Base类
}


//A类
class A extends Base{
    // 返回两个数的差
    public int func1(int num1, int num2) {
        return num1 - num2;
    }
}

//B 类继承了A
//增加了一个新功能，完成两个数相加，然后和9求和
class B extends Base {

    //如果B需要使用 A类的方法，使用组合关系
    private A a = new A();

    //无意间重写了父类的方法
    public int func1(int a, int b) {
        return a + b;
    }

    public int func2(int a, int b) {
        return func1(a, b) + 9;
    }

    //我们仍然想使用A的方法
    public int func3(int a,int b){
        System.out.println("仍想使用a的方法");
        return this.a.func1(a,b);
    }
}
